package Study2;

import java.util.Scanner;

/**
 * 进一步有关字符串的方法探究
 */
public class Study23 {
    /**
     * StringBuffer()  与 StringBuilder() 的区别
     * @param args
     */

    /*
       @Override
    public synchronized StringBuffer append(String str) {
        toStringCache = null;
        super.append(str);
        return this;

        synchronized  线程安全
    }

     @Override
    public StringBuilder append(String str) {
        super.append(str); 没有线程安全
        return this;
    }
1. String 的拼接会产生大量的临时对象，StringBuilder以及StringBuffer不会
2. String 的拼接会被优化为StringBuilder 的append
3. StringBuffer 当中有一些方法是 String 不具有的 ，逆置方法
4. StringBuilder 和 String 一般用于单线程情况下，StringBuffer 一般用于多线程情况下
     */
    public static void main(String[] args) {
        // StringBuffer中的倒置方法
        StringBuffer stringBuffer = new StringBuffer();
        stringBuffer.append("hello world");
        stringBuffer.reverse();   // 倒置方法
        System.out.println(stringBuffer);

    }

    public static void main22(String[] args) {
        StringBuilder stringBuilder = new StringBuilder();
        StringBuffer stringBuffer = new StringBuffer();
        stringBuffer.append("s");


        for (int i = 0; i < 10; i++) {
            stringBuilder.append("a");
        }
        System.out.println(stringBuilder.append("S"));
    }


    public static void main20(String[] args) {
        String str = "";

        for (int i = 0; i < 10; i++) {
            str += "a";
        }

        System.out.println(str);

    }




    /**
     * 输入 3
     *    abcdefg
     * 输出
     * defgabc
     *
     */

    /*
    方法 a b c d e f g
         c b a d e f g    前面的先倒置
         c b a g f e d    后面的倒置
         d e f g a b c    最后整体倒置
     */
    public static void main18(String[] args) {
        Scanner scanner = new Scanner(System.in);
        String str = "abcdefg";
        System.out.println(str);
        int n = scanner.nextInt();

        String ret = dans(str,n);
        System.out.println(ret);
    }

    public static String dans(String str,int n) {
        if(null == str || n < 0 || n > str.length()) {
            return null;
        }

        str = reverse(str,0,n-1);
        str = reverse(str,n,str.length()-1);
        str = reverse(str,0,str.length()-1);

        return str;
    }

    public static String reverse(String str, int begin, int end) {
        char[] value = str.toCharArray();     // 将字符串转为字节数组，取出一个下标倒置，交换位置
        while(begin < end) {
            char tmp = value[begin];
            value[begin] = value[end];
            value[end] = tmp;
            begin ++;
            end --;
        }

        return new String(value);
        /*
        或者使用字节数组转为字符串的方法
        String.copyralueof(value)'
         */
    }

    /**
     * 字符串中的 length ,和数组中的length
     */
    public static void main19(String[] args) {
        String str = "abcdef";
        int[] arrys = {1,2,3,4,5,6};
        System.out.println(str.length());   // 字符串中的length 是接口
        System.out.println(arrys.length);   // 数组中的length 是属性
    }


    /**
     * 其他有意思的方法
     */

    /*
    将大写的字母转为小写的，
    仅仅时字母，中文是不可以大小写转化的所以不变
    toLowerCase() 大写的转为小写的字母
    toUpperCase()
     */
    public static void main17(String[] args) {
        String str = "aaSSSAAAccc你好世界";
        String ret = str.toUpperCase();
        System.out.println(ret);
    }


    public static void main16(String[] args) {
        String str = "abdAAAAccc你好世界";
        String string = str.toLowerCase();
        System.out.println(string);

    }



    /**
     * 字符串的拆分
     * @param args
     */
    // 多次输入以空格拆分，并拼接
    public static void main15(String[] args) {
        Scanner scanner = new Scanner(System.in);

        while(scanner.hasNext()) {
            String str = scanner.nextLine();
            /*
            不能使用 next()与空格就结束了
            nextLine()不可以输入数值一起使用nextInt();
             */

            String ret = func(str);
            System.out.println(ret);
        }
    }
    public static String func(String str) {
        String[] strings = str.split(" ");  // 以空格拆分

        String tmp = "";

        for (String s:strings) {
            tmp += s;
        }

        return tmp;
    }



    /*
    多次拆分
    一次一次的使用 split 拆分一个一个
    * */
    public static void main14(String[] args) {
        String str = "Java-sqit#bit";
        String[] strings = str.split("#");
        for (String s:strings) {
            String[] strings1 = s.split("-");
            for (String s2:strings1) {
                System.out.println(s2);
            }
        }


    }


    public static void main13(String[] args){
        String str = "Java-sqit#bit";
        String[] strings = str.split("|-|#");
        System.out.println(strings.length);
        for (String s:strings) {
            System.out.println(s);
        }
    }



    /*
    查找时的特殊处理，特殊分隔符的处理
     ".$|()[{^?*+\\". 这些特殊标准的拆分符号，需要转义字符 \ ,
     时双斜杆的转义字符，\\ 把  \ 转义为真正的斜杆
     对于一个转移字符 \，需要两个转义字符 \\ 表示
     \\ 需要 四个转义字符表示 \\\\

    * */
    public static void main12(String[] args) {
        String str = "192\\168\\1\\1";
        String[] strings  = str.split("\\\\");
        System.out.println(strings.length);

        for (String s:strings) {
            System.out.println(s);
        }
    }


    public static void main11(String[] args) {
        String str = "192*168*1*1";
        String[] strings = str.split("\\*");
        System.out.println(strings.length);
        for (String s:strings) {
            System.out.println(s);
        }
    }

    public static void main10(String[] args) {
        String str = "192.168.1.1";
        String[] string = str.split("\\.");
        System.out.println(string.length);
        for (String s:string) {
            System.out.println(s);
        }
    }


    public static void main9(String[] args) {
        String str = "192.168.1.1";
        String[] strings = str.split(".");
        // 完全没有拆分
        System.out.println(strings.length);
        for (String s:strings) {
            System.out.println(s);
        }
    }


    /*
    split("x"),以某种形式拆分字符串，拆分返回字符串类型数组
    没有对应拆分形式不对，就不会拆分,但是依然是以字符串数组的类型返回
    * */
    public static void main8(String[] args) {
        String str = "hello world !!1";
        String[] strings = str.split("k");
        System.out.println(strings.length);
        for (String s:strings) {
            System.out.println(s);

        }

    }

    public static void main7(String[] args) {
      String str = "abc he will";
      String[] strings = str.split(" ");
        for (String s: strings) {
            System.out.println(s);
        }
    }



    /**
     * 字符串查找
     * 在字符串中查找是否存在该子串，字符串的匹配算法
     * 1. 朴素算法
     * 2. KMP算法
     *
     * @param args
     */

    /*
    判断子串是否在字符串中的结尾
    是返回 true ,不是或不存在该子串，返回true
    * */
    public static void main6(String[] args) {
        String str = "ababcabc";
        boolean flg = str.endsWith("abdc");
        System.out.println(flg);
    }
    /*
    判断字符串中子串是否存在于 指定下标位置的开头
    是返回 true,不是，不存在返回 false
    * */
    public static void main5(String[] args) {
        String str = "avabcabc";
        boolean flg = str.startsWith("abcd",2);
        System.out.println(flg);
    }



    /*
    startsWith("xxx")判断子串是否存在字符串中的开头位置
    存在返回 true,不存在返回 false
    * */
    public static void main4(String[] args) {
        String str = "abcabd";
        boolean flg = str.startsWith("abfc");
        System.out.println(flg);
    }

    /*
    indexOf("xxx",9); 从字符串中的指定位置开始查找子串的
    下标位置，没有该子串返回 -1
    * */
    public static void main3(String[] args) {
        String str = "abdabcabdabc";
        int flg = str.indexOf("abc",0);
        System.out.println(flg);
    }



    /*
    方法 indexOf(),从字符串开头查找该子串的位置，
    该字符串中存在该子串返回其在字符串中的下标位置
    没有该子串，返回下标 -1；
    * */
    public static void main2(String[] args) {
        String str = "ababcabca";
        int flg = str.indexOf("abec");
        System.out.println(flg);
    }

    /*
    关键字 contains
    判断字符串中是否含有该子串，有返回 true, 否则 false
    * */
    public static void main1(String[] args) {
        String str = "ababcabcdaed";
        boolean flg = str.contains("abc");
        System.out.println(flg);
    }
}
